```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JVM内存模型深度解析 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
            -webkit-font-smoothing: antialiased;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            margin-top: 1.5em;
            margin-bottom: 0.8em;
            line-height: 1.3;
        }
        .hero {
            background: linear-gradient(135deg, #2c3e50 0%, #3498db 100%);
            color: white;
        }
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .feature-icon {
            width: 60px;
            height: 60px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            margin-bottom: 1.5rem;
            font-size: 1.5rem;
        }
        .diagram-container {
            background: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            margin: 2rem 0;
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
        }
        .comparison-table {
            width: 100%;
            border-collapse: collapse;
            margin: 2rem 0;
        }
        .comparison-table th, .comparison-table td {
            padding: 12px 15px;
            text-align: left;
            border-bottom: 1px solid #e2e8f0;
        }
        .comparison-table th {
            background-color: #f7fafc;
            font-weight: 600;
        }
        .comparison-table tr:hover {
            background-color: #f8fafc;
        }
        .highlight-box {
            background-color: #f8fafc;
            border-left: 4px solid #4299e1;
            padding: 1.5rem;
            margin: 2rem 0;
            border-radius: 0 0.5rem 0.5rem 0;
        }
        .nav-link {
            transition: all 0.2s ease;
        }
        .nav-link:hover {
            color: #4299e1;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0 md:pr-10">
                    <h1 class="text-4xl md:text-5xl font-bold mb-6">JVM内存模型深度解析</h1>
                    <p class="text-xl opacity-90 mb-8">掌握Java程序运行机制的核心知识，优化应用性能的关键所在</p>
                    <div class="flex flex-wrap gap-4">
                        <a href="#overview" class="bg-white text-blue-800 hover:bg-gray-100 px-6 py-3 rounded-lg font-medium transition duration-300">
                            <i class="fas fa-book-open mr-2"></i>开始阅读
                        </a>
                        <a href="#visualization" class="border-2 border-white text-white hover:bg-white hover:text-blue-800 px-6 py-3 rounded-lg font-medium transition duration-300">
                            <i class="fas fa-project-diagram mr-2"></i>可视化图表
                        </a>
                    </div>
                </div>
                <div class="md:w-1/2">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1734600885650-4bd85a61-8bb8-4aa6-b745-3c43d9857c68.png" 
                         alt="JVM内存模型示意图" 
                         class="rounded-lg shadow-xl w-full h-auto">
                </div>
            </div>
        </div>
    </section>

    <!-- Navigation -->
    <nav class="bg-white shadow-sm sticky top-0 z-10">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex overflow-x-auto py-4 space-x-6">
                <a href="#overview" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-map mr-2"></i>概述
                </a>
                <a href="#structure" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-sitemap mr-2"></i>结构组成
                </a>
                <a href="#heap" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-layer-group mr-2"></i>堆内存细化
                </a>
                <a href="#class" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-cubes mr-2"></i>类加载与方法区
                </a>
                <a href="#stack" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-code-branch mr-2"></i>JVM栈与线程
                </a>
                <a href="#direct" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-memory mr-2"></i>直接内存
                </a>
                <a href="#gc" class="nav-link whitespace-nowrap font-medium text-gray-700 hover:text-blue-600">
                    <i class="fas fa-recycle mr-2"></i>内存回收策略
                </a>
            </div>
        </div>
    </nav>

    <!-- Main Content -->
    <main class="container mx-auto max-w-5xl px-4 py-12">
        <!-- Overview Section -->
        <section id="overview" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">JVM内存模型概述</h2>
            </div>
            
            <p class="text-lg mb-6">JVM内存模型（Java Memory Model, JMM）定义了线程之间如何共享变量以及如何保证线程安全。它不仅决定了Java程序中对象的分配和回收，还深刻影响了多线程环境下的代码行为。</p>
            
            <div class="highlight-box">
                <p><strong>为什么需要理解JVM内存模型？</strong> 为什么有些代码在本地测试一切正常，放到生产环境却会出问题？为什么有时明明已经设置了多线程同步，结果却不符合预期？这些问题往往都与JVM内存模型相关。</p>
            </div>
            
            <div class="grid md:grid-cols-3 gap-6 mt-10">
                <div class="card bg-white p-6 rounded-lg">
                    <div class="feature-icon bg-blue-100 text-blue-600">
                        <i class="fas fa-shield-alt"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">线程安全性</h3>
                    <p class="text-gray-600">确保多线程程序中的数据一致性，避免因并发修改共享变量导致的错误。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <div class="feature-icon bg-green-100 text-green-600">
                        <i class="fas fa-laptop-code"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">跨平台性</h3>
                    <p class="text-gray-600">屏蔽底层硬件和操作系统的差异，让Java程序在不同平台上表现一致。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <div class="feature-icon bg-purple-100 text-purple-600">
                        <i class="fas fa-tachometer-alt"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">高效性</h3>
                    <p class="text-gray-600">通过一定程度的优化和重排序，提升程序的运行效率，同时维持正确性。</p>
                </div>
            </div>
        </section>

        <!-- Structure Section -->
        <section id="structure" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">JVM内存区域划分</h2>
            </div>
            
            <p class="text-lg mb-6">JVM在运行时将内存划分为若干区域，以支持Java程序的高效执行。这些区域根据用途不同，可以分为线程私有区域和线程共享区域。</p>
            
            <div class="diagram-container">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1734600950624-e6c75bcb-80b8-4724-b677-2ab7df800076.png" 
                     alt="JVM内存区域划分示意图" 
                     class="rounded-lg w-full h-auto">
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mt-8">
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-blue-700 flex items-center">
                        <i class="fas fa-user-shield mr-2"></i> 线程私有区域
                    </h3>
                    <div class="space-y-4">
                        <div class="bg-white p-4 rounded-lg shadow">
                            <h4 class="font-bold text-lg mb-2">程序计数器</h4>
                            <p class="text-gray-600">记录当前线程正在执行的字节码指令地址。是线程私有的，独立于其他线程。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg shadow">
                            <h4 class="font-bold text-lg mb-2">Java虚拟机栈</h4>
                            <p class="text-gray-600">保存每个线程的方法调用信息，包括局部变量、操作数栈、动态链接和方法出口等。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg shadow">
                            <h4 class="font-bold text-lg mb-2">本地方法栈</h4>
                            <p class="text-gray-600">为本地方法（Native方法）服务，支持调用非Java语言实现的函数。</p>
                        </div>
                    </div>
                </div>
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-green-700 flex items-center">
                        <i class="fas fa-users mr-2"></i> 线程共享区域
                    </h3>
                    <div class="space-y-4">
                        <div class="bg-white p-4 rounded-lg shadow">
                            <h4 class="font-bold text-lg mb-2">堆（Heap）</h4>
                            <p class="text-gray-600">存储所有的对象实例和数组。是线程共享的区域，几乎所有的对象实例都存储在堆中。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg shadow">
                            <h4 class="font-bold text-lg mb-2">方法区</h4>
                            <p class="text-gray-600">存储类元信息、常量池、静态变量和即时编译器生成的代码。自JDK 8起，方法区被替换为元空间。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg shadow">
                            <h4 class="font-bold text-lg mb-2">运行时常量池</h4>
                            <p class="text-gray-600">存储编译时生成的各种字面量和符号引用。是方法区的一部分。</p>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-2xl font-semibold mb-4 text-purple-700 flex items-center">
                    <i class="fas fa-exchange-alt mr-2"></i> 内存区域交互关系
                </h3>
                <ol class="space-y-3 pl-6 list-decimal text-gray-700">
                    <li><strong>程序计数器</strong>负责指向当前指令，与虚拟机栈中的方法调用关联。</li>
                    <li><strong>虚拟机栈</strong>与本地方法栈共同支持方法的执行，负责局部变量的存储。</li>
                    <li><strong>堆</strong>作为对象存储的主要区域，与栈中的对象引用保持交互。</li>
                    <li><strong>方法区</strong>存储类元信息，加载时被堆中对象引用。</li>
                </ol>
            </div>
        </section>

        <!-- Heap Memory Section -->
        <section id="heap" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">堆内存细化</h2>
            </div>
            
            <p class="text-lg mb-6">在JVM中，堆内存是用来存储对象实例和数组的主要区域，同时也是垃圾回收的核心管理区域。为了更高效地分配对象和执行垃圾回收，堆内存通常被细分为以下几个区域：</p>
            
            <div class="grid md:grid-cols-2 gap-8 mt-8">
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg mb-6">
                        <h3 class="text-2xl font-semibold mb-4 text-blue-700">新生代（Young Generation）</h3>
                        <p class="mb-4">适合存储生命周期较短的对象。</p>
                        <ul class="space-y-3 pl-6 list-disc text-gray-700">
                            <li>新生代又分为三个部分：Eden区和两个Survivor区（S0、S1）</li>
                            <li>新生代的垃圾回收频繁，采用<strong>Minor GC</strong>（小型垃圾回收）</li>
                            <li>通常Eden区占新生代80%的空间</li>
                        </ul>
                    </div>
                    
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-green-700">老年代（Old Generation）</h3>
                        <p class="mb-4">存储生命周期较长或从新生代晋升的对象。</p>
                        <ul class="space-y-3 pl-6 list-disc text-gray-700">
                            <li>垃圾回收较少，但耗时较长，通常采用<strong>Major GC 或 Full GC</strong>（完全垃圾回收）</li>
                            <li>如果老年代空间不足，会抛出<code>OutOfMemoryError: Java heap space</code></li>
                        </ul>
                    </div>
                </div>
                
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg h-full">
                        <h3 class="text-2xl font-semibold mb-4 text-purple-700">堆内存管理</h3>
                        <div class="mb-6">
                            <h4 class="font-bold text-lg mb-2">对象晋升条件</h4>
                            <ul class="space-y-2 pl-6 list-disc text-gray-700">
                                <li>对象的年龄（Survivor区的存活次数）达到某个阈值（默认15次）</li>
                                <li>Survivor区无法容纳所有存活对象时，直接晋升到老年代</li>
                            </ul>
                        </div>
                        <div>
                            <h4 class="font-bold text-lg mb-2">常用JVM参数</h4>
                            <div class="bg-gray-100 p-4 rounded-md">
                                <code class="block mb-2">-Xms</code>
                                <p class="text-sm text-gray-600 mb-3">设置堆的初始大小</p>
                                
                                <code class="block mb-2">-Xmx</code>
                                <p class="text-sm text-gray-600 mb-3">设置堆的最大大小</p>
                                
                                <code class="block mb-2">-XX:NewRatio</code>
                                <p class="text-sm text-gray-600 mb-3">设置新生代与老年代的比例（默认值为1:2）</p>
                                
                                <code class="block mb-2">-XX:SurvivorRatio</code>
                                <p class="text-sm text-gray-600">设置Eden区与Survivor区的比例（默认值为8:1:1）</p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-2xl font-semibold mb-4 text-orange-700">元空间（Metaspace，JDK 8及以上）</h3>
                <div class="bg-white p-6 rounded-lg shadow-lg">
                    <p class="mb-4">在JDK 8之前，方法区是堆的一部分，称为永久代（PermGen）。JDK 8之后，永久代被替换为<strong>元空间（Metaspace）</strong>：</p>
                    <ul class="space-y-3 pl-6 list-disc text-gray-700">
                        <li>存储类的元信息，例如类的结构、方法、常量池等</li>
                        <li>存储在直接内存中，不再受堆内存的限制</li>
                        <li>元空间大小可以通过<code>-XX:MetaspaceSize</code>和<code>-XX:MaxMetaspaceSize</code>参数配置</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Class Loading Section -->
        <section id="class" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">类加载与方法区</h2>
            </div>
            
            <p class="text-lg mb-6">在 JVM 的运行时体系结构中，<strong>类加载</strong>与<strong>方法区</strong>紧密相关。类加载机制负责将类的字节码加载到 JVM 并将其存储在方法区，而方法区则用来存储类的元数据、常量、静态变量等信息。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mt-8">
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg mb-6">
                        <h3 class="text-2xl font-semibold mb-4 text-blue-700">类加载的生命周期</h3>
                        <div class="space-y-4">
                            <div>
                                <h4 class="font-bold text-lg mb-2">1. 加载（Loading）</h4>
                                <p class="text-gray-600">将类的字节码从文件或其他数据源（如网络）读取到内存。生成 <code>Class</code> 对象，作为该类的内存入口。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">2. 验证（Verification）</h4>
                                <p class="text-gray-600">检查类的字节码是否符合 JVM 的规范（例如类型安全、操作码合法性）。确保字节码没有破坏 Java 虚拟机的运行安全。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">3. 准备（Preparation）</h4>
                                <p class="text-gray-600">为类的静态变量分配内存，并赋初始值（默认值，例如 <code>int</code> 为 0）。此时未执行任何程序代码。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">4. 解析（Resolution）</h4>
                                <p class="text-gray-600">将常量池中的符号引用（例如类名、方法名）替换为直接引用（内存地址）。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">5. 初始化（Initialization）</h4>
                                <p class="text-gray-600">执行类的静态初始化代码块和静态变量的赋值语句。</p>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg h-full">
                        <h3 class="text-2xl font-semibold mb-4 text-purple-700">方法区概述</h3>
                        <p class="mb-4">方法区是 JVM 内存模型的一部分，属于线程共享区域。它用于存储与类相关的数据，主要包括以下内容：</p>
                        
                        <ul class="space-y-3 pl-6 list-disc text-gray-700 mb-6">
                            <li>类的元数据（类名、父类信息、接口、字段和方法的描述等）</li>
                            <li>静态变量</li>
                            <li>常量池（运行时常量池）</li>
                            <li>方法代码（字节码）</li>
                        </ul>
                        
                        <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4 mb-6">
                            <p class="font-semibold">JDK 8 变化</p>
                            <p class="text-gray-700">在 JDK 8 之前，方法区是 <strong>永久代（PermGen）</strong> 的一部分；在 JDK 8 及之后，永久代被移除，改为使用 <strong>元空间（Metaspace）</strong>，其存储在直接内存中。</p>
                        </div>
                        
                        <div>
                            <h4 class="font-bold text-lg mb-2">运行时常量池</h4>
                            <p class="text-gray-600 mb-4">是方法区的一部分，存储类和接口的常量信息，包括字面量（如字符串常量 "hello"）和符号引用（如类名、方法名）。在类加载的解析阶段，符号引用会被解析为内存地址。</p>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-2xl font-semibold mb-4 text-green-700">双亲委派机制</h3>
                <div class="bg-white p-6 rounded-lg shadow-lg">
                    <p class="mb-4">类加载器采用 <strong>双亲委派机制</strong>，即先将加载任务委托给父加载器，只有当父加载器无法加载时，才由当前加载器尝试加载。</p>
                    
                    <div class="grid md:grid-cols-3 gap-6 mt-6">
                        <div class="text-center">
                            <div class="bg-blue-100 rounded-full w-16 h-16 flex items-center justify-center mx-auto mb-3">
                                <i class="fas fa-cog text-blue-600 text-2xl"></i>
                            </div>
                            <h4 class="font-bold">启动类加载器</h4>
                            <p class="text-sm text-gray-600">加载核心类库（<code>$JAVA_HOME/lib</code>）</p>
                        </div>
                        <div class="text-center">
                            <div class="bg-green-100 rounded-full w-16 h-16 flex items-center justify-center mx-auto mb-3">
                                <i class="fas fa-expand text-green-600 text-2xl"></i>
                            </div>
                            <h4 class="font-bold">扩展类加载器</h4>
                            <p class="text-sm text-gray-600">加载扩展类库（<code>$JAVA_HOME/lib/ext</code>）</p>
                        </div>
                        <div class="text-center">
                            <div class="bg-purple-100 rounded-full w-16 h-16 flex items-center justify-center mx-auto mb-3">
                                <i class="fas fa-code text-purple-600 text-2xl"></i>
                            </div>
                            <h4 class="font-bold">应用类加载器</h4>
                            <p class="text-sm text-gray-600">加载应用程序类路径（classpath）中的类</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- JVM Stack Section -->
        <section id="stack" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">JVM栈与线程内存</h2>
            </div>
            
            <p class="text-lg mb-6">JVM 栈（Java Virtual Machine Stack）是 JVM 内存模型的重要组成部分，它与线程的生命周期密切相关。每个线程在执行 Java 程序时会拥有一个独立的 JVM 栈，主要用于存储方法调用过程中的局部变量、操作数栈、方法返回值以及常量引用。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mt-8">
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-blue-700">栈帧结构</h3>
                        <div class="space-y-4">
                            <div>
                                <h4 class="font-bold text-lg mb-2">局部变量表</h4>
                                <p class="text-gray-600">存储方法的局部变量，包括基本数据类型和对象引用。按索引访问（从 0 开始），索引由编译器分配。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">操作数栈</h4>
                                <p class="text-gray-600">用于保存计算过程中的中间结果和操作数。遵循 "后进先出" 原则。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">动态链接</h4>
                                <p class="text-gray-600">保存方法调用过程中的符号引用到实际引用的转换信息。支持动态绑定，保证多态的实现。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">方法返回地址</h4>
                                <p class="text-gray-600">保存方法调用完成后返回的位置。</p>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-purple-700">常见问题与优化</h3>
                        <div class="space-y-4">
                            <div>
                                <h4 class="font-bold text-lg mb-2">栈溢出（StackOverflowError）</h4>
                                <p class="text-gray-600">当方法递归调用过深或栈帧数量超过 JVM 栈的最大深度时触发。解决方法：优化递归算法或使用 <code>-Xss</code> 参数调整栈大小。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">栈内存不足（OutOfMemoryError）</h4>
                                <p class="text-gray-600">当 JVM 无法为新的线程分配栈内存时触发。解决方法：减少线程数量或增大 JVM 堆外内存。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">优化建议</h4>
                                <ul class="space-y-2 pl-6 list-disc text-gray-700">
                                    <li>合理分配栈大小（<code>-Xss512k</code>）</li>
                                    <li>避免过多的线程（使用线程池）</li>
                                    <li>优化递归算法（使用迭代替代）</li>
                                    <li>减少对象创建（降低栈压力）</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-2xl font-semibold mb-4 text-green-700">内存区域对比</h3>
                <div class="overflow-x-auto">
                    <table class="comparison-table">
                        <thead>
                            <tr>
                                <th>内存区域</th>
                                <th>线程归属</th>
                                <th>主要用途</th>
                                <th>是否线程安全</th>
                            </tr>
                        </thead>
                        <tbody>
                            <tr>
                                <td><strong>JVM 栈</strong></td>
                                <td>线程私有</td>
                                <td>方法调用与执行相关数据</td>
                                <td>是</td>
                            </tr>
                            <tr>
                                <td><strong>堆内存</strong></td>
                                <td>线程共享</td>
                                <td>存储对象实例与数组</td>
                                <td>否（需同步）</td>
                            </tr>
                            <tr>
                                <td><strong>方法区</strong></td>
                                <td>线程共享</td>
                                <td>存储类元信息、静态变量等</td>
                                <td>否（需同步）</td>
                            </tr>
                            <tr>
                                <td><strong>本地方法栈</strong></td>
                                <td>线程私有</td>
                                <td>执行本地方法的调用</td>
                                <td>是</td>
                            </tr>
                        </tbody>
                    </table>
                </div>
            </div>
        </section>

        <!-- Direct Memory Section -->
        <section id="direct" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">直接内存（Direct Memory）</h2>
            </div>
            
            <p class="text-lg mb-6">直接内存是指由操作系统提供的内存区域，它不受 Java 堆的管理，而是直接通过操作系统进行分配和回收。在 Java 中，直接内存通常是指通过 <code>java.nio.ByteBuffer</code> 类的 <code>allocateDirect()</code> 方法分配的内存。</p>
            
            <div class="bg-blue-50 p-6 rounded-lg mb-8">
                <h3 class="text-xl font-semibold mb-4 text-blue-700">直接内存的特点</h3>
                <ul class="space-y-3 pl-6 list-disc text-gray-700">
                    <li><strong>不在 JVM 堆中</strong>：直接由操作系统分配和管理</li>
                    <li><strong>高效的 I/O 操作</strong>：减少内存复制，提高 I/O 性能</li>
                    <li><strong>不受垃圾回收影响</strong>：由操作系统直接管理，不经过 JVM GC</li>
                    <li><strong>使用限制</strong>：需要特别注意资源回收，避免内存泄漏</li>
                </ul>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mt-8">
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-purple-700">基本使用</h3>
                        <div class="bg-gray-800 rounded-lg p-4 mb-4">
                            <pre class="text-green-400 text-sm overflow-x-auto">
<code>import java.nio.ByteBuffer;

public class DirectMemoryDemo {
    public static void main(String[] args) {
        // 分配 1MB 的直接内存
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
        
        // 使用直接内存
        buffer.put((byte) 1);  // 向缓冲区写入数据
        
        // 读取数据
        byte value = buffer.get(0);
        System.out.println("Value: " + value);
    }
}</code></pre>
                        </div>
                        <p class="text-gray-600">直接内存的分配通过 <code>ByteBuffer.allocateDirect()</code> 方法完成，使用时需注意释放资源。</p>
                    </div>
                </div>
                
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-green-700">对比：直接内存 vs 堆内存</h3>
                        <table class="comparison-table">
                            <thead>
                                <tr>
                                    <th>特性</th>
                                    <th>直接内存</th>
                                    <th>堆内存</th>
                                </tr>
                            </thead>
                            <tbody>
                                <tr>
                                    <td><strong>分配方式</strong></td>
                                    <td>通过操作系统直接分配</td>
                                    <td>由 JVM 堆内存管理</td>
                                </tr>
                                <tr>
                                    <td><strong>管理方式</strong></td>
                                    <td>操作系统管理</td>
                                    <td>由 JVM GC 管理</td>
                                </tr>
                                <tr>
                                    <td><strong>性能</strong></td>
                                    <td>更高效，减少复制</td>
                                    <td>可能有 GC 开销</td>
                                </tr>
                                <tr>
                                    <td><strong>用途</strong></td>
                                    <td>主要用于 I/O 操作</td>
                                    <td>用于对象存储</td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-2xl font-semibold mb-4 text-orange-700">应用场景</h3>
                <div class="grid md:grid-cols-2 gap-6">
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-network-wired text-blue-500 mr-2"></i> 高性能网络编程
                        </h4>
                        <p class="text-gray-600">如高吞吐量的 Web 服务器、数据库客户端、文件服务器等，直接内存能够显著提高数据传输效率。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-database text-green-500 mr-2"></i> 大数据处理
                        </h4>
                        <p class="text-gray-600">大数据应用通常需要处理大量的 I/O 操作，使用直接内存能够避免堆内存和 GC 的性能瓶颈。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-file-alt text-purple-500 mr-2"></i> 文件读写操作
                        </h4>
                        <p class="text-gray-600">读取大文件时，通过直接内存可以减少内存复制，从而提高读取效率。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-photo-video text-red-500 mr-2"></i> 图形处理和多媒体
                        </h4>
                        <p class="text-gray-600">如视频流的编码解码、图形渲染等，也常用到直接内存来提高数据处理速度。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- GC Section -->
        <section id="gc" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">内存分配与回收策略</h2>
            </div>
            
            <p class="text-lg mb-6">内存分配和回收是计算机系统中非常重要的两个概念，尤其是在 JVM（Java虚拟机）环境中，内存管理的有效性直接影响应用程序的性能和稳定性。内存分配和回收涉及多个方面，包括堆内存、栈内存、直接内存等的分配与回收机制。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mt-8">
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-blue-700">内存分配方式</h3>
                        <div class="space-y-4">
                            <div>
                                <h4 class="font-bold text-lg mb-2">静态分配</h4>
                                <p class="text-gray-600">静态分配的内存是在程序编译时就已经确定好的，内存大小在程序执行过程中不变，通常是在栈内存中分配的局部变量或方法参数的内存空间。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">动态分配</h4>
                                <ul class="space-y-2 pl-6 list-disc text-gray-700">
                                    <li><strong>堆内存分配</strong>：通过 <code>new</code> 关键字触发，由 GC 管理</li>
                                    <li><strong>栈内存分配</strong>：用于方法调用中的局部变量</li>
                                    <li><strong>直接内存分配</strong>：通过 <code>ByteBuffer.allocateDirect()</code> 分配</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div>
                    <div class="bg-white p-6 rounded-lg shadow-lg">
                        <h3 class="text-2xl font-semibold mb-4 text-purple-700">垃圾回收算法</h3>
                        <div class="space-y-4">
                            <div>
                                <h4 class="font-bold text-lg mb-2">标记-清除算法（Mark-Sweep）</h4>
                                <p class="text-gray-600">首先标记所有需要回收的对象，然后清除这些标记的对象所占的内存空间。优点简单，但可能导致内存碎片。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">复制算法（Copying）</h4>
                                <p class="text-gray-600">将内存空间分为两部分，每次只使用其中一部分。减少内存碎片，但浪费一半内存。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">标记-整理算法（Mark-Compact）</h4>
                                <p class="text-gray-600">类似标记-清除，但将存活对象移动到堆的连续区域，避免内存碎片。</p>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg mb-2">分代收集算法</h4>
                                <p class="text-gray-600">根据对象的生命周期将堆内存划分为年轻代、老年代和持久代，提升回收效率。</p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-2xl font-semibold mb-4 text-green-700">优化策略</h3>
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-cogs text-blue-500 mr-2"></i> 垃圾回收器选择
                        </h4>
                        <p class="text-gray-600">JVM 提供了多种垃圾回收器，包括 Serial GC、Parallel GC、CMS GC 和 G1 GC。根据应用特点选择适合的回收器。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-chart-line text-purple-500 mr-2"></i> 堆大小调整
                        </h4>
                        <p class="text-gray-600">合理调整堆内存的大小可以提高垃圾回收的效率。过小的堆会导致频繁GC，过大的堆会增加停顿时间。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow">
                        <h4 class="font-bold text-lg mb-3 flex items-center">
                            <i class="fas fa-search text-green-500 mr-2"></i> 内存泄漏监测
                        </h4>
                        <p class="text-gray-600">通过内存分析工具（如 VisualVM、JProfiler 等）监控和检测内存泄漏问题，确保系统稳定性。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Visualization Section -->
        <section id="visualization" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-1 bg-blue-500 w-12 mr-4"></div>
                <h2 class="text-3xl font-bold">JVM内存模型可视化</h2>
            </div>
            
            <p class="text-lg mb-6">通过交互式图表直观展示JVM内存模型的关键概念和它们之间的关系。</p>
            
            <div class="bg-white p-6 rounded-lg shadow-lg mb-8">
                <div class="mermaid">
                    graph TD
                        A[JVM内存模型] --> B[线程私有区域]
                        A --> C[线程共享区域]
                        
                        B --> B1[程序计数器]
                        B --> B2[Java虚拟机栈]
                        B --> B3[本地方法栈]
                        
                        C --> C1[堆]
                        C --> C2[方法区]
                        C --> C3[运行时常量池]
                        
                        C1 --> C11[新生代]
                        C1 --> C12[老年代]
                        
                        C11 --> C111[Eden区]
                        C11 --> C112[Survivor0]
                        C11 --> C113[Survivor1]
                        
                        C2 --> C21[类元信息]
                        C2 --> C22[静态变量]
                        C2 --> C23[即时编译代码]
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-lg shadow-lg">
                <div class="mermaid">
                    flowchart LR
                        GC[垃圾回收算法] --> MarkSweep[标记-清除]
                        GC --> Copying[复制算法]
                        GC --> MarkCompact[标记-整理]
                        GC --> Generational[分代收集]
                        
                        MarkSweep --> MSPros[简单]
                        MarkSweep --> MSCons[内存碎片]
                        
                        Copying --> CPros[无碎片]
                        Copying --> CCons[浪费空间]
                        
                        MarkCompact --> MCPros[减少碎片]
                        MarkCompact --> MCCons[移动开销]
                        
                        Generational --> GPros[效率高]
                        Generational --> GCons[老年代停顿]
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-12">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-6 md:mb-0">
                    <h3 class="text-xl font-bold mb-2">技术小馆</h3>
                    <p class="text-gray-400">专注技术分享与知识传播</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-blue-400 hover:text-blue-300 transition duration-300">
                        <i class="fas fa-external-link-alt mr-2"></i>技术小馆地址
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-gray-500 text-sm">
                <p>© 2024 技术小馆. 保留所有权利.</p>
            </div>
        </div>
    </footer>

    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // Smooth scrolling for anchor links
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
    </script>
</body>
</html>
```